{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个实例中，我们使用tensorflow来实现一个简单的手写数字识别的网络，并用这个网络来做个\n",
    "简单的识别示例。\n",
    "\n",
    "首先导入一些用到的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:50.515650Z",
     "start_time": "2018-06-01T06:32:43.133728Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/framework/ops.py:939: DeprecationWarning: builtin type EagerTensor has no __module__ attribute\n",
      "  EagerTensor = c_api.TFE_Py_InitEagerTensor(_EagerTensorBase)\n",
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/util/tf_inspect.py:55: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() or inspect.getfullargspec()\n",
      "  if d.decorator_argspec is not None), _inspect.getargspec(target))\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:39:48.304594Z",
     "start_time": "2018-06-01T04:55:17.674707Z"
    }
   },
   "source": [
    "先来看看数据长什么样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.075054Z",
     "start_time": "2018-06-01T06:32:50.518290Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-a34a30334354>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /home/david/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/david/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/david/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/david/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/david/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:49:40.128071Z",
     "start_time": "2018-06-01T05:49:40.123888Z"
    }
   },
   "source": [
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量，\n",
    "所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.695746Z",
     "start_time": "2018-06-01T06:32:51.077167Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个bool类型的变量用于标识当前网络是否正在训练。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.706044Z",
     "start_time": "2018-06-01T06:32:51.698913Z"
    }
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为我们输入的是图片展开后的一维向量，所以第一步就需要先把一维向量还原为二维的图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.719298Z",
     "start_time": "2018-06-01T06:32:51.707730Z"
    }
   },
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:07:36.530623Z",
     "start_time": "2018-06-01T06:07:36.522665Z"
    }
   },
   "source": [
    "接下来，我们定义第一个卷积层，使用6个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式选择valid，所以输出数据的宽高变为24x24,但是深度已经从原来的1变成了6。\n",
    "本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.764292Z",
     "start_time": "2018-06-01T06:32:51.721295Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来进行stride为2的最大池化，池化后，输出深度不变，但是长宽减半，所以输出变成了12x12,深度6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.774112Z",
     "start_time": "2018-06-01T06:32:51.766784Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:10:16.678485Z",
     "start_time": "2018-06-01T06:10:16.671472Z"
    }
   },
   "source": [
    "接下来，我们定义第二个卷积层，使用16个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式还是选择valid，输出8x8,深度为16，本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.805912Z",
     "start_time": "2018-06-01T06:32:51.776959Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再进行一次stride为2的最大池化，输出为4x4,深度16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.814748Z",
     "start_time": "2018-06-01T06:32:51.807560Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据是3维的，这里做一个拉平的操作，将3维数据展开到1维，然后送入两层全连接，全连接隐层中神经元个数分别为120，84。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.856740Z",
     "start_time": "2018-06-01T06:32:51.817287Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:17:39.880958Z",
     "start_time": "2018-06-01T06:17:39.869797Z"
    }
   },
   "source": [
    "###### 对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout，\n",
    "所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.913419Z",
     "start_time": "2018-06-01T06:32:51.860766Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits,\n",
    "这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。\n",
    "\n",
    ">试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.084738Z",
     "start_time": "2018-06-01T06:32:51.915376Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-3c77ec77605a>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/util/tf_inspect.py:55: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() or inspect.getfullargspec()\n",
      "  if d.decorator_argspec is not None), _inspect.getargspec(target))\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:25:56.449132Z",
     "start_time": "2018-06-01T06:25:56.438340Z"
    }
   },
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布，\n",
    "要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:39:50.010829Z",
     "start_time": "2018-06-01T06:39:49.997501Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/util/tf_inspect.py:55: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() or inspect.getfullargspec()\n",
      "  if d.decorator_argspec is not None), _inspect.getargspec(target))\n"
     ]
    }
   ],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.127795Z",
     "start_time": "2018-06-01T06:32:52.103115Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:35:22.270272Z",
     "start_time": "2018-06-01T06:33:18.829198Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.340937, the validation accuracy is 0.9016\n",
      "after 200 training steps, the loss is 0.23556, the validation accuracy is 0.9518\n",
      "after 300 training steps, the loss is 0.25062, the validation accuracy is 0.9598\n",
      "after 400 training steps, the loss is 0.200403, the validation accuracy is 0.9706\n",
      "after 500 training steps, the loss is 0.130072, the validation accuracy is 0.9702\n",
      "after 600 training steps, the loss is 0.23336, the validation accuracy is 0.9718\n",
      "after 700 training steps, the loss is 0.154975, the validation accuracy is 0.9714\n",
      "after 800 training steps, the loss is 0.0854684, the validation accuracy is 0.9782\n",
      "after 900 training steps, the loss is 0.0600702, the validation accuracy is 0.982\n",
      "after 1000 training steps, the loss is 0.0115384, the validation accuracy is 0.9798\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9825\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:58:16.766415Z",
     "start_time": "2018-06-01T06:58:15.918700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
